home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / HTML / QuickForm / group.php < prev    next >
PHP Script  |  2004-10-01  |  16KB  |  524 lines
  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4: */
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.0 of the PHP license,       |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: Adam Daniel <adaniel1@eesus.jnj.com>                        |
  17. // |          Bertrand Mansion <bmansion@mamasam.com>                     |
  18. // +----------------------------------------------------------------------+
  19. //
  20. // $Id: group.php,v 1.33 2004/02/08 16:01:28 mansion Exp $
  21.  
  22. require_once("HTML/QuickForm/element.php");
  23.  
  24. /**
  25.  * HTML class for a form element group
  26.  * 
  27.  * @author       Adam Daniel <adaniel1@eesus.jnj.com>
  28.  * @author       Bertrand Mansion <bmansion@mamasam.com>
  29.  * @version      1.0
  30.  * @since        PHP4.04pl1
  31.  * @access       public
  32.  */
  33. class HTML_QuickForm_group extends HTML_QuickForm_element
  34. {
  35.     // {{{ properties
  36.         
  37.     /**
  38.      * Name of the element
  39.      * @var       string
  40.      * @since     1.0
  41.      * @access    private
  42.      */
  43.     var $_name = '';
  44.  
  45.     /**
  46.      * Array of grouped elements
  47.      * @var       array
  48.      * @since     1.0
  49.      * @access    private
  50.      */
  51.     var $_elements = array();
  52.  
  53.     /**
  54.      * String to separate elements
  55.      * @var       mixed
  56.      * @since     2.5
  57.      * @access    private
  58.      */
  59.     var $_separator = null;
  60.  
  61.     /**
  62.      * Required elements in this group
  63.      * @var       array
  64.      * @since     2.5
  65.      * @access    private
  66.      */
  67.     var $_required = array();
  68.  
  69.    /**
  70.     * Whether to change elements' names to $groupName[$elementName] or leave them as is 
  71.     * @var      bool
  72.     * @since    3.0
  73.     * @access   private
  74.     */
  75.     var $_appendName = true;
  76.  
  77.     // }}}
  78.     // {{{ constructor
  79.  
  80.     /**
  81.      * Class constructor
  82.      * 
  83.      * @param     string    $elementName    (optional)Group name
  84.      * @param     array     $elementLabel   (optional)Group label
  85.      * @param     array     $elements       (optional)Group elements
  86.      * @param     mixed     $separator      (optional)Use a string for one separator,
  87.      *                                      use an array to alternate the separators.
  88.      * @param     bool      $appendName     (optional)whether to change elements' names to
  89.      *                                      the form $groupName[$elementName] or leave 
  90.      *                                      them as is.
  91.      * @since     1.0
  92.      * @access    public
  93.      * @return    void
  94.      */
  95.     function HTML_QuickForm_group($elementName=null, $elementLabel=null, $elements=null, $separator=null, $appendName = true)
  96.     {
  97.         $this->HTML_QuickForm_element($elementName, $elementLabel);
  98.         $this->_type = 'group';
  99.         if (isset($elements) && is_array($elements)) {
  100.             $this->setElements($elements);
  101.         }
  102.         if (isset($separator)) {
  103.             $this->_separator = $separator;
  104.         }
  105.         if (isset($appendName)) {
  106.             $this->_appendName = $appendName;
  107.         }
  108.     } //end constructor
  109.     
  110.     // }}}
  111.     // {{{ setName()
  112.  
  113.     /**
  114.      * Sets the group name
  115.      * 
  116.      * @param     string    $name   Group name
  117.      * @since     1.0
  118.      * @access    public
  119.      * @return    void
  120.      */
  121.     function setName($name)
  122.     {
  123.         $this->_name = $name;
  124.     } //end func setName
  125.     
  126.     // }}}
  127.     // {{{ getName()
  128.  
  129.     /**
  130.      * Returns the group name
  131.      * 
  132.      * @since     1.0
  133.      * @access    public
  134.      * @return    string
  135.      */
  136.     function getName()
  137.     {
  138.         return $this->_name;
  139.     } //end func getName
  140.  
  141.     // }}}
  142.     // {{{ setValue()
  143.  
  144.     /**
  145.      * Sets values for group's elements
  146.      * 
  147.      * @param     mixed    Values for group's elements
  148.      * @since     1.0
  149.      * @access    public
  150.      * @return    void
  151.      */
  152.     function setValue($value)
  153.     {
  154.         if (empty($this->_elements)) {
  155.             $this->_createElements();
  156.         }
  157.         foreach (array_keys($this->_elements) as $key) {
  158.             if (!$this->_appendName) {
  159.                 $v = $this->_elements[$key]->_findValue($value);
  160.                 if (null !== $v) {
  161.                     $this->_elements[$key]->onQuickFormEvent('setGroupValue', $v, $this);
  162.                 }
  163.  
  164.             } else {
  165.                 $elementName = $this->_elements[$key]->getName();
  166.                 $index       = (!empty($elementName)) ? $elementName : $key;
  167.                 if (is_array($value)) {
  168.                     if (isset($value[$index])) {
  169.                         $this->_elements[$key]->onQuickFormEvent('setGroupValue', $value[$index], $this);
  170.                     }
  171.                 } elseif (isset($value)) {
  172.                     $this->_elements[$key]->onQuickFormEvent('setGroupValue', $value, $this);
  173.                 }
  174.             }
  175.         }
  176.     } //end func setValue
  177.     
  178.     // }}}
  179.     // {{{ getValue()
  180.  
  181.     /**
  182.      * Returns the value of the group
  183.      *
  184.      * @since     1.0
  185.      * @access    public
  186.      * @return    mixed
  187.      */
  188.     function getValue()
  189.     {
  190.         $value = null;
  191.         foreach (array_keys($this->_elements) as $key) {
  192.             $element =& $this->_elements[$key];
  193.             switch ($element->getType()) {
  194.                 case 'radio': 
  195.                     $v = $element->getChecked()? $element->getValue(): null;
  196.                     break;
  197.                 case 'checkbox': 
  198.                     $v = $element->getChecked()? true: null;
  199.                     break;
  200.                 default:
  201.                     $v = $element->getValue();
  202.             }
  203.             if (null !== $v) {
  204.                 $elementName = $element->getName();
  205.                 if (is_null($elementName)) {
  206.                     $value = $v;
  207.                 } else {
  208.                     if (!is_array($value)) {
  209.                         $value = is_null($value)? array(): array($value);
  210.                     }
  211.                     if ('' == $elementName) {
  212.                         $value[] = $v;
  213.                     } else {
  214.                         $value[$elementName] = $v;
  215.                     }
  216.                 }
  217.             }
  218.         }
  219.         return $value;
  220.     } // end func getValue
  221.  
  222.     // }}}
  223.     // {{{ setElements()
  224.  
  225.     /**
  226.      * Sets the grouped elements
  227.      *
  228.      * @param     array     $elements   Array of elements
  229.      * @since     1.1
  230.      * @access    public
  231.      * @return    void
  232.      */
  233.     function setElements($elements)
  234.     {
  235.         $this->_elements = array_values($elements);
  236.     } // end func setElements
  237.  
  238.     // }}}
  239.     // {{{ getElements()
  240.  
  241.     /**
  242.      * Gets the grouped elements
  243.      *
  244.      * @since     2.4
  245.      * @access    public
  246.      * @return    array
  247.      */
  248.     function &getElements()
  249.     {
  250.         return $this->_elements;
  251.     } // end func getElements
  252.  
  253.     // }}}
  254.     // {{{ getGroupType()
  255.  
  256.     /**
  257.      * Gets the group type based on its elements
  258.      * Will return 'mixed' if elements contained in the group
  259.      * are of different types.
  260.      *
  261.      * @access    public
  262.      * @return    string    group elements type
  263.      */
  264.     function getGroupType()
  265.     {
  266.         if (empty($this->_elements)) {
  267.             $this->_createElements();
  268.         }
  269.         $prevType = '';
  270.         foreach (array_keys($this->_elements) as $key) {
  271.             $type = $this->_elements[$key]->getType();
  272.             if ($type != $prevType && $prevType != '') {
  273.                 return 'mixed';
  274.             }
  275.             $prevType = $type;
  276.         }
  277.         return $type;
  278.     } // end func getGroupType
  279.  
  280.     // }}}
  281.     // {{{ toHtml()
  282.  
  283.     /**
  284.      * Returns Html for the group
  285.      * 
  286.      * @since       1.0
  287.      * @access      public
  288.      * @return      string
  289.      */
  290.     function toHtml()
  291.     {
  292.         include_once('HTML/QuickForm/Renderer/Default.php');
  293.         $renderer =& new HTML_QuickForm_Renderer_Default();
  294.         $renderer->setElementTemplate('{element}');
  295.         $this->accept($renderer);
  296.         return $renderer->toHtml();
  297.     } //end func toHtml
  298.     
  299.     // }}}
  300.     // {{{ getElementName()
  301.  
  302.     /**
  303.      * Returns the element name inside the group such as found in the html form
  304.      * 
  305.      * @param     mixed     $index  Element name or element index in the group
  306.      * @since     3.0
  307.      * @access    public
  308.      * @return    mixed     string with element name, false if not found
  309.      */
  310.     function getElementName($index)
  311.     {
  312.         if (empty($this->_elements)) {
  313.             $this->_createElements();
  314.         }
  315.         $elementName = false;
  316.         if (is_int($index) && isset($this->_elements[$index])) {
  317.             $elementName = $this->_elements[$index]->getName();
  318.             if (isset($elementName) && $elementName == '') {
  319.                 $elementName = $index;
  320.             }
  321.             if ($this->_appendName) {
  322.                 if (is_null($elementName)) {
  323.                     $elementName = $this->getName();
  324.                 } else {
  325.                     $elementName = $this->getName().'['.$elementName.']';
  326.                 }
  327.             }
  328.  
  329.         } elseif (is_string($index)) {
  330.             foreach (array_keys($this->_elements) as $key) {
  331.                 $elementName = $this->_elements[$key]->getName();
  332.                 if ($index == $elementName) {
  333.                     if ($this->_appendName) {
  334.                         $elementName = $this->getName().'['.$elementName.']';
  335.                     }
  336.                     break;
  337.                 } elseif ($this->_appendName && $this->getName().'['.$elementName.']' == $index) {
  338.                     break;
  339.                 }
  340.             }
  341.         }
  342.         return $elementName;
  343.     } //end func getElementName
  344.  
  345.     // }}}
  346.     // {{{ getFrozenHtml()
  347.  
  348.     /**
  349.      * Returns the value of field without HTML tags
  350.      * 
  351.      * @since     1.3
  352.      * @access    public
  353.      * @return    string
  354.      */
  355.     function getFrozenHtml()
  356.     {
  357.         $tmp = $this->_flagFrozen;
  358.         $this->_flagFrozen = true;
  359.         $html = $this->toHtml();
  360.         $this->_flagFrozen = $tmp;
  361.         return $html;
  362.     } //end func getFrozenHtml
  363.  
  364.     // }}}
  365.     // {{{ onQuickFormEvent()
  366.  
  367.     /**
  368.      * Called by HTML_QuickForm whenever form event is made on this element
  369.      *
  370.      * @param     string    $event  Name of event
  371.      * @param     mixed     $arg    event arguments
  372.      * @param     object    $caller calling object
  373.      * @since     1.0
  374.      * @access    public
  375.      * @return    void
  376.      */
  377.     function onQuickFormEvent($event, $arg, &$caller)
  378.     {
  379.         switch ($event) {
  380.             case 'updateValue':
  381.                 if (empty($this->_elements)) {
  382.                     $this->_createElements();
  383.                 }
  384.                 foreach (array_keys($this->_elements) as $key) {
  385.                     if ($this->_appendName) {
  386.                         $elementName = $this->_elements[$key]->getName();
  387.                         if (is_null($elementName)) {
  388.                             $this->_elements[$key]->setName($this->getName());
  389.                         } elseif ('' == $elementName) {
  390.                             $this->_elements[$key]->setName($this->getName() . '[' . $key . ']');
  391.                         } else {
  392.                             $this->_elements[$key]->setName($this->getName() . '[' . $elementName . ']');
  393.                         }
  394.                     }
  395.                     $this->_elements[$key]->onQuickFormEvent('updateValue', $arg, $caller);
  396.                     if ($this->_appendName) {
  397.                         $this->_elements[$key]->setName($elementName);
  398.                     }
  399.                 }
  400.                 break;
  401.  
  402.             default:
  403.                 parent::onQuickFormEvent($event, $arg, $caller);
  404.         }
  405.         return true;
  406.     } // end func onQuickFormEvent
  407.  
  408.     // }}}
  409.     // {{{ accept()
  410.  
  411.    /**
  412.     * Accepts a renderer
  413.     *
  414.     * @param object     An HTML_QuickForm_Renderer object
  415.     * @param bool       Whether a group is required
  416.     * @param string     An error message associated with a group
  417.     * @access public
  418.     * @return void 
  419.     */
  420.     function accept(&$renderer, $required = false, $error = null)
  421.     {
  422.         if (empty($this->_elements)) {
  423.             $this->_createElements();
  424.         }
  425.         $renderer->startGroup($this, $required, $error);
  426.         $name = $this->getName();
  427.         foreach (array_keys($this->_elements) as $key) {
  428.             $element =& $this->_elements[$key];
  429.             
  430.             if ($this->_appendName) {
  431.                 $elementName = $element->getName();
  432.                 if (isset($elementName)) {
  433.                     $element->setName($name . '['. (strlen($elementName)? $elementName: $key) .']');
  434.                 } else {
  435.                     $element->setName($name);
  436.                 }
  437.             }
  438.  
  439.             if ($this->_flagFrozen) {
  440.                 $element->freeze();
  441.             }
  442.             $required = !$this->_flagFrozen && in_array($element->getName(), $this->_required);
  443.  
  444.             $element->accept($renderer, $required);
  445.  
  446.             // restore the element's name
  447.             if ($this->_appendName) {
  448.                 $element->setName($elementName);
  449.             }
  450.         }
  451.         $renderer->finishGroup($this);
  452.     } // end func accept
  453.  
  454.     // }}}
  455.     // {{{ exportValue()
  456.  
  457.    /**
  458.     * As usual, to get the group's value we access its elements and call
  459.     * their exportValue() methods
  460.     */
  461.     function exportValue(&$submitValues, $assoc = false)
  462.     {
  463.         $value = null;
  464.         foreach (array_keys($this->_elements) as $key) {
  465.             $elementName = $this->_elements[$key]->getName();
  466.             if ($this->_appendName) {
  467.                 if (is_null($elementName)) {
  468.                     $this->_elements[$key]->setName($this->getName());
  469.                 } elseif ('' == $elementName) {
  470.                     $this->_elements[$key]->setName($this->getName() . '[' . $key . ']');
  471.                 } else {
  472.                     $this->_elements[$key]->setName($this->getName() . '[' . $elementName . ']');
  473.                 }
  474.             }
  475.             $v = $this->_elements[$key]->exportValue($submitValues, $assoc);
  476.             if ($this->_appendName) {
  477.                 $this->_elements[$key]->setName($elementName);
  478.             }
  479.             if (null !== $v) {
  480.                 // Make $value an array, we will use it like one
  481.                 if (null === $value) {
  482.                     $value = array();
  483.                 }
  484.                 if ($assoc) {
  485.                     // just like HTML_QuickForm::exportValues()
  486.                     $value = HTML_QuickForm::arrayMerge($value, $v);
  487.                 } else {
  488.                     // just like getValue(), but should work OK every time here
  489.                     if (is_null($elementName)) {
  490.                         $value = $v;
  491.                     } elseif ('' == $elementName) {
  492.                         $value[] = $v;
  493.                     } else {
  494.                         $value[$elementName] = $v;
  495.                     }
  496.                 }
  497.             }
  498.         }
  499.         // do not pass the value through _prepareValue, we took care of this already
  500.         return $value;
  501.     }
  502.  
  503.     // }}}
  504.     // {{{ _createElements()
  505.  
  506.    /**
  507.     * Creates the group's elements.
  508.     * 
  509.     * This should be overriden by child classes that need to create their 
  510.     * elements. The method will be called automatically when needed, calling
  511.     * it from the constructor is discouraged as the constructor is usually
  512.     * called _twice_ on element creation, first time with _no_ parameters.
  513.     * 
  514.     * @access private
  515.     * @abstract
  516.     */
  517.     function _createElements()
  518.     {
  519.         // abstract
  520.     }
  521.  
  522.     // }}}
  523. } //end class HTML_QuickForm_group
  524. ?>